import { Context, Next } from 'koa';
import AnalyService from '../../service/Admin/Analy.service'
import { compress } from 'compress-json'
import { spawn, Worker, Thread } from 'threads'
class AnalyController {
    private dataQueryWorker: any = null;
    
    // 初始化数据查询工作线程
    public async initDataQueryWorker() {
        if (!this.dataQueryWorker) {
            this.dataQueryWorker = await spawn(new Worker('../../until/dataQueryWorker'));
            console.log('数据查询工作线程初始化完成');
        }
        return this.dataQueryWorker;
    }
    
     // 获取分析曲线
    async getAnayleRecord(ctx:Context) {
        try {
            let startTime:any = ctx.query.startTime // 获取开始的时间
            let endTime:any = ctx.query.endTime //获取结束的时间
            let module_id:any = ctx.query.module_id // 那个模块
            let module_type:any = ctx.query.module_type // 那个传感器
            let gateway_ip:any = ctx.query.gateway_ip // 网关IP
            console.log(ctx.query)
            // 使用工作线程处理数据查询
            const worker = await this.initDataQueryWorker();
            const result = await worker.getAnalyRecord({
                startTime,
                endTime,
                module_id: parseInt(module_id),
                module_type,
                gateway_ip
            });
            let mapArr: object[] = [];

        if (module_type === "uvc") {
            result.data.forEach((item:any) => {
                if (item[module_type] && item[module_type].indexOf(",") !== -1) {
                    item[module_type].split(',').forEach((e:any,i:number) => {
                        mapArr.push({
                            uvc: e,
                            timer: item.timer + '-' + i * 100,
                            time: item.time + '-' + i * 100,
                            gateway_ip: item.gateway_ip,
                            module_id: item.module_id
                        });
                    });
                } else {
                    mapArr.push({
                        uvc: item[module_type],
                        timer: item.timer,
                        time: item.time,
                        gateway_ip: item.gateway_ip,
                        module_id: item.module_id
                    });
                }
            });
        } else {
            mapArr = result.data;
        }
         ctx.body = {
                code: 200,
                msg: "获取数据成功",
                data: compress(mapArr),
                total: result.total,
                module_id: result.module_id,
                module_type: result.module_type,
                date_range: result.date_range
            };
        } catch (error) {
            console.error('获取分析数据失败:', error);
            ctx.body = {
                code: 500,
                msg: "获取数据失败",
                data: null
            };
        }
    }

    async getHistoryData(ctx:Context) {
       try {
        const gateway_ip = ctx.query.gateway_ip as string; // 网关IP
        const module_id = ctx.query.module_id as string; // 设备ID
        const type = ctx.query.type as string; // 数据类型
        const pageSize = parseInt(ctx.query.pageSize as string) || 10; // 分页大小
        const page = parseInt(ctx.query.page as string) || 1; // 页码

        if (!gateway_ip || !module_id || !type) {
            ctx.body = {
                code: 400,
                msg: "参数错误，需要提供gateway_ip、module_id和type",
                data: null
            };
            return;
        }

        // 使用工作线程处理历史数据查询
        const worker = await this.initDataQueryWorker();
        const data = await worker.getHistoryDataByType({
            gateway_ip,
            module_id,
            type,
            pageSize,
            page
        });
        
        ctx.body = {
            code: 200,
            msg: "获取历史数据成功",
            data
        };
    } catch (error) {
        console.error('获取历史数据失败:', error);
        ctx.body = {
            code: 500,
            msg: "获取历史数据失败"
        };
    }
    }
    
    // 清理工作线程资源
    async cleanup() {
        if (this.dataQueryWorker) {
            try {
                await this.dataQueryWorker.terminate();
                this.dataQueryWorker = null;
                console.log('数据查询工作线程已清理');
            } catch (error) {
                console.error('清理工作线程失败:', error);
            }
        }
    }
}

export default new AnalyController()